package cn.mujiankeji.mbrowser.界面.标签页.快照

import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.combinedClickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import cn.mujiankeji.mbrowser.app.MBrowserApp
import cn.mujiankeji.mbrowser.app.应用接口
import cn.mujiankeji.mbrowser.app.应用路由
import cn.mujiankeji.mbrowser.功能.BackstageWebView
import cn.mujiankeji.mbrowser.功能.播放框.播放框视图实现
import cn.mujiankeji.mbrowser.功能.播放框.核心.ExoPlayer
import cn.mujiankeji.mbrowser.功能.播放框.模型.播放内容来源
import cn.mujiankeji.mbrowser.功能.播放框.模型.播放文件信息
import cn.mujiankeji.mbrowser.功能.播放框.模型.播放框视图状态
import cn.mujiankeji.mbrowser.工具.mlog
import cn.mujiankeji.mbrowser.工具.操作.地址操作
import cn.mujiankeji.mbrowser.数据.枚举类.页面状态枚举
import cn.mujiankeji.mbrowser.数据.快照来源.快照源_视频
import cn.mujiankeji.mbrowser.数据.快照来源.快照来源接口
import cn.mujiankeji.mbrowser.数据.配置项.应用配置
import cn.mujiankeji.mbrowser.界面.图标.MyIconPack
import cn.mujiankeji.mbrowser.界面.图标.myiconpack.信息
import cn.mujiankeji.mbrowser.界面.组件.自适应宫格列表
import cn.nr19.jian.`object`.JianLei

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withContext
import 界面.弹窗.下拉菜单
import 界面.弹窗.下拉菜单项目

class 视频播放项目(var title : String,var url : String){
    var videoUrls : List<String> ?= null
    var videoUrl : String = "" // 选中播放的
}
class 快照状态_视频(val 来源 : 快照源_视频) : 快照状态() {

    override fun 来源(): 快照来源接口 = 来源
    var 显示播放框 by mutableStateOf(true) // 本页面是否显示播放框（焦点被全屏、画中画抢走时不显示）

    val 播放源 = object : 播放内容来源<视频播放项目>(){

        override suspend fun 取播放文件(
            item: 视频播放项目,
            loadStateCallback: (String) -> Unit
        ): 播放文件信息 {
            if (来源.嗅探 && item.videoUrls==null || item.videoUrl.isEmpty()){
                val ls = ArrayList<String>()
               BackstageWebView(item.url)
                    .getStrResponse{
                        loadStateCallback.invoke(it)
                        if (地址操作.是否为视频地址(it).also { b->
                            mlog("xxx",b,it)
                            }){
                            ls.add(it)
                        }
                    }.body().also {
                        mlog("result",it)
                   }

                item.videoUrls = ls
            }


            mlog("end",item.videoUrls?.size,item.url)
            if (item.videoUrls != null){
                if (item.videoUrls!!.isNotEmpty()){
                    item.videoUrl = item.videoUrls!![0]
                }
                return 播放文件信息(地址 = item.videoUrl.ifEmpty { item.url },
                    标题 = item.title,
                    协议头 = null)
            }



            return 播放文件信息(地址 = item.url,
                标题 = item.title,
                协议头 = null)
        }

        override fun 取标题(item: 视频播放项目): String {
            return item.title.ifEmpty { item.url }
        }

        override suspend fun 预加载(item: 视频播放项目) {
            //
            mlog("预加载项目")
        }

    }

    var 播放框 = 播放框视图状态(
        context = MBrowserApp.ctx(),
        player = ExoPlayer(MBrowserApp.ctx()),
        播放源 = 播放源,
        更新视频倍速 = {
            coroutine?.launch {
                应用配置.设置视频默认倍速(it)
            }
        },
        界面状态改变 = { 全屏, 画中画 ->
            if (全屏){
                显示播放框 = false
                应用全屏()
            }
            else if (画中画){
                显示播放框 = false
                应用画中画()
            }
            else{
                应用接口.界面模块().取消全屏()
                显示播放框 = true
            }
        },
        准备就绪 = {
            播放框准备就绪()
        }
    )

    var 简介 by mutableStateOf<String>("")

    private fun 应用全屏(){
        应用接口.界面模块().设置全屏视图 {
            播放框视图实现(播放框)
        }
    }
    private fun 应用画中画(){
        应用接口.界面模块().设置画中画({
            播放框.取消画中画()
        }){
            播放框视图实现(播放框)
        }
    }
    override fun 后退(): Boolean {
        if (播放框.全屏模式){
            播放框.取消全屏()
            return true
        }
        else if (播放框.画中画模式){
            播放框.取消画中画()
            return true
        }
        return super.后退()
    }
    private fun 播放框准备就绪(){
        // todo 自动播放
    }


    override suspend fun CoroutineScope.加载(code: String) {
        super.加载进度.value = 90

        val jian = JianLei()
        withContext(Dispatchers.IO){
            super.标题.value = tryText(code,来源.标题,jian)
            简介 = tryText(code,来源.简介,jian)
            播放源.播放源列表.clear()

            suspend fun Playlist(content : String,jian : JianLei) : List<视频播放项目>{
                val list = ArrayList<视频播放项目>()
                tryList(content,来源.播放项目,jian)?.forEach {
                    val name = tryText(it,来源.播放标题,jian)
                    val url = tryUrl(it,来源.播放地址,jian)?:""
                    list.add(视频播放项目(name,url))
                }
                return list
            }



            var i = 1
            val sources = ArrayList<String>()
            val playlist = ArrayList<List<视频播放项目>>()


            // 取播放源
            if (!来源.源列表.isNullOrEmpty()){
                tryList(code,来源.源列表!!,jian)?.forEach { blockContent->
                    var name = ""
                    来源.源标题?.let {
                        name =  tryText(blockContent,it,jian)
                    }
                    if (name.isEmpty()) name = "源 ${i}"
                    i++

                    if (来源.播放列表.isNullOrEmpty()){
                        播放源.播放源列表[name] = Playlist(blockContent,jian)
                    }else{
                        sources.add(name)
                    }

                }
            }


            // 未在播放源中取到播放列表
            if (!来源.播放列表.isNullOrEmpty()){
                playlist.clear()
                tryList(code,来源.播放列表!!,jian)?.forEach {
                    playlist.add(Playlist(it,jian))
                }
                mlog("playlist",playlist.size)

                // 默认命名
                if (sources.isEmpty()){
                    var i2  = 1
                    playlist.forEach {
                        播放源.播放源列表["p ${i2}"] = it
                        i2++
                    }
                }

                // 取到的源较多，则以源为准
                else if (sources.size > playlist.size){
                    playlist.forEachIndexed { index, list ->
                        播放源.播放源列表[sources[index]] = list
                    }
                }

                // 否则就随便咯
                else{
                    sources.forEachIndexed {index,name->
                        播放源.播放源列表[name] = playlist[index]
                    }
                }

            }


            // 最后取一次
            if (播放源.播放源列表.isEmpty()){
                播放源.播放源列表["默认源"] = Playlist(code,jian)
            }

            super.加载进度.value = 100
            super.状态.value = 页面状态枚举.完成
        }
    }


}


@Composable
fun 快照实现_视频(state : 快照状态_视频){
    快照页面布局(state,true){
        LazyColumn(
            Modifier.fillMaxSize()
            .background(MaterialTheme.colorScheme.background)) {

            // 播放框
            item {
                Box(
                    Modifier.fillMaxWidth()
                    .background(Color.Black)
                    .height(230.dp),){
                    if (state.显示播放框){
                        播放框视图实现(state.播放框)
                    }
                }
            }

            // 视频信息
            item {
                视频信息操作视图(state)
            }

            // 视频来源
            item {
                视频来源视图(state)
            }

        }
    }
}

@Composable
private fun 视频信息操作视图(state: 快照状态_视频){
    var 后台播放 by remember { mutableStateOf(false) }
    var 视频倍速 by remember { mutableStateOf(1f) }
    var 显示视频信息 by remember { mutableStateOf(false) } // 应当信息框显示媒体的基本信息
    var 播放文件信息 by remember { mutableStateOf<播放文件信息?>(null) }


    // 后台播放
    LaunchedEffect(Unit) {
        应用配置.读取视频后台播放().collect{
            后台播放 = it
        }
    }

    // 配速
    LaunchedEffect(Unit) {
        应用配置.读取视频默认倍速().collect{
            视频倍速 = it
        }
    }

    // 播放文件改变
    LaunchedEffect(state.播放框.player.视频信息) {
        state.播放框?.player?.视频信息?.collect{
            播放文件信息 = it
        }

    }

    Card(colors = CardDefaults
        .elevatedCardColors()
        .copy(containerColor = MaterialTheme.colorScheme.surface),
        modifier = Modifier.padding(horizontal = 10.dp, vertical = 5.dp)
    ) {
        Column(Modifier.fillMaxWidth()
            .padding(horizontal = 15.dp, vertical = 10.dp))
        {

            // 后台  倍速  信息
            Row(Modifier.fillMaxWidth().height(55.dp),
                verticalAlignment = Alignment.CenterVertically){

                Text("选项", style = MaterialTheme.typography.titleMedium)


                Spacer(Modifier.weight(1f))

                FilterChip(selected = 后台播放,{
                    state.coroutine?.launch {
                        应用配置.设置视频后台播放(!后台播放)
                    }
                }, label = {
                    Text("后台")
                })

                Spacer(Modifier.width(6.dp))


                var 显示倍速菜单 by remember { mutableStateOf(false) }
                FilterChip(selected = false,{
                    显示倍速菜单 =true
                }, label = {
                    Text("倍速:${视频倍速}")
                    下拉菜单(显示倍速菜单,{显示倍速菜单 = false}){
                        listOf(0.5f,1.0f,1.25f,1.5f,2f,2.5f,3.0f,4.0f).forEach {
                            下拉菜单项目(it.toString()){
                                state.coroutine?.launch {
                                    应用配置.设置视频默认倍速(it)
                                    state.播放框.player.设置播放速率(it)
                                    显示倍速菜单 = false
                                }
                            }
                        }
                    }
                })

                Spacer(Modifier.width(6.dp))

                IconButton({
                    显示视频信息 = true
                }) {
                    Icon(
                        MyIconPack.信息,"",
                        tint = MaterialTheme.colorScheme.surfaceTint)
                }



            }

            Spacer(Modifier.height(10.dp))

            // 视频源列表
            /*LazyRow {
                items(播放源.播放源列表){
                    FilterChip(it == state.播放中的视频地址,
                        onClick = {state.切换播放源地址(it)},
                        label = { Text(it) })
                }
            }
            */
            Spacer(Modifier.height(10.dp))


            // 当前播放的视频地址
            Text(播放文件信息?.地址?:"", color = MaterialTheme.colorScheme.primary,
                maxLines = 6, style = MaterialTheme.typography.labelSmall)


            Spacer(Modifier.height(10.dp))




        }

    }



}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun  视频来源视图(state: 快照状态_视频){

    val 播放源 = state.播放框.播放源
    // 本地显示的播放源
    var 选中的播放源分类名称 by remember { mutableStateOf<String?>(null) }
    val 当前播放项目 = state.播放框.当前播放项目
    LaunchedEffect(播放源.播放源列表) {
        if (选中的播放源分类名称.isNullOrEmpty()){
            if (播放源.播放源列表.entries.size >= 1) {
                选中的播放源分类名称 = 播放源.播放源列表.entries.first().key
            }
        }
    }

    Card(colors = CardDefaults
        .elevatedCardColors()
        .copy(containerColor = MaterialTheme.colorScheme.surface),
        modifier = Modifier.padding(horizontal = 10.dp, vertical = 5.dp)
    ){
        Column(Modifier.padding(horizontal = 10.dp, vertical = 10.dp)) {


            FlowRow {
                播放源.播放源列表.toList().forEach {
                    FilterChip(selected = it.first == 选中的播放源分类名称,
                        onClick = {
                            选中的播放源分类名称 = it.first
                        },
                        label = { Text(it.first) },
                        modifier = Modifier.padding(horizontal = 5.dp))
                }
            }

            Spacer(Modifier.fillMaxWidth().background(MaterialTheme.colorScheme.outlineVariant)
                .height(.5.dp))
            Spacer(Modifier.height(10.dp))


            FlowRow(Modifier.fillMaxWidth()) {
                选中的播放源分类名称?.let { name->

                    播放源.取列表(name)?.let {
                        自适应宫格列表(90.dp,it){
                            var showm by remember { mutableStateOf(false) }
                            var showt by remember { mutableStateOf(false) }
                            if (showt){
                                AlertDialog({showt = false}){
                                    Text(it.url)
                                }
                            }
                            Box(Modifier.padding(horizontal = 3.dp)
                                .then(if (it == 当前播放项目) Modifier.background(MaterialTheme.colorScheme.primary)
                                    else Modifier.border(1.dp, MaterialTheme.colorScheme.outlineVariant,MaterialTheme.shapes.extraSmall))
                                .height(28.dp)
                                .fillMaxWidth()
                                .combinedClickable(
                                    onClick = {
                                        state.coroutine?.launch {
                                            state.播放框.设置播放项目(选中的播放源分类名称!!,it)
                                        }
                                    },
                                    onLongClick = {
                                        showm = true
                                    }
                                ), contentAlignment = Alignment.Center) {
                                Text(播放源.取标题(it), style = MaterialTheme.typography.bodyMedium,
                                    maxLines = 1,
                                    color = if (it == 当前播放项目) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant,)
                            }
                        }
                    }

                }
            }


        }
    }
}